import axios from 'axios';

// 查询条件持久化参数接口
export interface PersistenceParams {
  displayInfoId: string;
  userId: string;
  queryName: string;
  searchForm: Record<string, any>;
  localSearchFormConfig?: any[];
}

// 持久化响应接口
export interface PersistenceResponse {
  success: boolean;
  message?: string;
  data?: any;
}

/**
 * 构建查询条件对象
 * @param searchForm 搜索表单数据
 * @param localSearchFormConfig 搜索表单配置（可选）
 * @returns 过滤后的查询条件对象
 */
export const buildQueryConditions = (
  searchForm: Record<string, any>,
  localSearchFormConfig?: any[]
): Record<string, any> => {
  const queryConditions: Record<string, any> = {};
  
  // 遍历搜索表单，过滤掉空值
  Object.keys(searchForm).forEach(key => {
    const value = searchForm[key];
    
    // 检查值是否为空
    if (isValueEmpty(value)) {
      return;
    }
    
    // 如果有表单配置，可以进行更精细的处理
    if (localSearchFormConfig) {
      const fieldConfig = localSearchFormConfig.find(field => 
        field.queryAttributeName === key
      );
      
      // 根据字段类型进行特殊处理
      if (fieldConfig) {
        queryConditions[key] = processFieldValue(value, fieldConfig);
      } else {
        queryConditions[key] = value;
      }
    } else {
      queryConditions[key] = value;
    }
  });

  return queryConditions;
};

/**
 * 判断值是否为空
 * @param value 要检查的值
 * @returns 是否为空
 */
export const isValueEmpty = (value: any): boolean => {
  if (value === null || value === undefined || value === '') {
    return true;
  }
  
  if (Array.isArray(value) && value.length === 0) {
    return true;
  }
  
  if (typeof value === 'object' && Object.keys(value).length === 0) {
    return true;
  }
  
  return false;
};

/**
 * 根据字段配置处理字段值
 * @param value 字段值
 * @param fieldConfig 字段配置
 * @returns 处理后的值
 */
export const processFieldValue = (value: any, fieldConfig: any): any => {
  // 日期范围特殊处理
  if (fieldConfig.queryEditType === 'datetime-range') {
    // 这里可以根据需要处理日期范围格式
    return value;
  }
  
  // 下拉选择多选处理
  if (fieldConfig.queryEditType === 'select' && Array.isArray(value)) {
    // 可以在这里对多选值进行格式化
    return value;
  }
  
  return value;
};

/**
 * 持久化查询条件
 * @param params 持久化参数
 * @returns 持久化结果
 */
export const persistQueryConditions = async (
  params: PersistenceParams,
  url: string
): Promise<PersistenceResponse> => {
  try {
    const { displayInfoId, userId, queryName, searchForm, localSearchFormConfig } = params;
    
    // 构建 KV JSON 格式的查询条件
    const queryConditions = buildQueryConditions(searchForm, localSearchFormConfig);
    
    // 如果没有查询条件，不进行保存
    if (Object.keys(queryConditions).length === 0) {
      return {
        success: true,
        message: '无查询条件，跳过保存'
      };
    }

    // 构建持久化参数
    const persistParams = {
      displayInfoId,
      queryInfo: JSON.stringify(queryConditions),
      queryName,
      userId
    };

    // 调用后端接口保存查询条件
    const response = await axios.post(
      url,
      persistParams
    );

    if (response.data && response.data.success) {
      return {
        success: true,
        message: '查询条件保存成功',
        data: response.data
      };
    } else {
      return {
        success: false,
        message: response.data?.message || '查询条件保存失败'
      };
    }
  } catch (error: any) {
    console.error('保存查询条件时发生错误:', error);
    return {
      success: false,
      message: error.message || '保存查询条件时发生错误'
    };
  }
};


export default {
  buildQueryConditions,
  isValueEmpty,
  processFieldValue,
  persistQueryConditions,
};